package com.leon.datalink.core.persistence;

import java.util.*;

/**
 * 节点Actor状态分析和分类
 * 
 * 根据不同Actor类型的状态特征，将其分类为：
 * 1. 关键状态Actor - 必须持久化，状态丢失会影响系统功能
 * 2. 业务状态Actor - 建议持久化，状态丢失会影响业务连续性
 * 3. 临时状态Actor - 可选持久化，状态丢失影响较小
 * 4. 无状态Actor - 无需持久化，重启后可自动恢复
 * 
 * @author leon
 */
public class NodeActorStateAnalysis {

    /**
     * 关键状态Actor - 必须持久化
     * 这些Actor的状态丢失会严重影响系统功能
     */
    public static final Map<String, String> CRITICAL_STATE_ACTORS = new HashMap<String, String>() {{
        // 规则管理Actor
        put("RuleActor", "管理规则生命周期，状态丢失会导致规则无法正常运行");
        
        // 调度节点Actor
        put("ScheduleNodeActor", "管理定时任务状态，状态丢失会导致调度失效");
        
        // 服务器类Actor - 需要维护连接状态
        put("HttpServerNodeActor", "HTTP服务器状态，包括连接池和会话信息");
        put("TcpNodeActor", "TCP连接状态，包括连接池和客户端信息");
        put("UdpNodeActor", "UDP服务状态，包括端口绑定和客户端信息");
        put("CoapServerNodeActor", "CoAP服务器状态，包括资源注册和客户端信息");
        
        // 文件监控Actor
        put("FileWatchNodeActor", "文件监控状态，包括监控位置和已处理记录");
        
        // 速度控制Actor
        put("SpeedNodeActor", "速度控制状态，包括队列和限流计数器");
        
        // 打包Actor
        put("PackNodeActor", "数据打包状态，包括缓存数据和打包计数器");
    }};

    /**
     * 业务状态Actor - 建议持久化
     * 这些Actor的状态丢失会影响业务连续性，但不会导致系统故障
     */
    public static final Map<String, String> BUSINESS_STATE_ACTORS = new HashMap<String, String>() {{
        // 驱动类Actor - 可能包含连接状态
        put("DriverNodeActor", "数据源驱动状态，包括连接池和事务状态");
        
        // 脚本执行Actor
        put("ScriptNodeActor", "脚本执行状态，包括编译缓存和执行上下文");
        
        // 插件Actor
        put("PluginNodeActor", "插件运行状态，包括插件实例和配置信息");
        
        // 命令执行Actor
        put("CommandNodeActor", "命令执行状态，包括执行历史和环境变量");
        
        // 文件写入Actor
        put("FileWriteNodeActor", "文件写入状态，包括写入位置和缓存数据");
        
        // HTTP响应Actor
        put("HttpResponseNodeActor", "HTTP响应状态，包括会话和响应缓存");
        
        // CoAP客户端Actor
        put("CoapClientNodeActor", "CoAP客户端状态，包括连接和请求历史");
        
        // HTTP客户端Actor
        put("HttpClientNodeActor", "HTTP客户端状态，包括连接池和请求历史");
    }};

    /**
     * 临时状态Actor - 可选持久化
     * 这些Actor的状态丢失影响较小，主要用于性能优化
     */
    public static final Map<String, String> TEMPORARY_STATE_ACTORS = new HashMap<String, String>() {{
        // 延迟Actor
        put("DelayNodeActor", "延迟处理状态，包括待处理任务队列");
        
        // 过滤Actor
        put("FilterNodeActor", "过滤器状态，包括过滤统计和缓存");
        
        // 模板Actor
        put("TemplateNodeActor", "模板处理状态，包括模板缓存和变量");
        
        // 开关Actor
        put("SwitchNodeActor", "开关状态，包括路由规则和统计信息");
    }};

    /**
     * 无状态Actor - 无需持久化
     * 这些Actor重启后可以自动恢复，无需保存状态
     */
    public static final Set<String> STATELESS_ACTORS = new HashSet<String>() {{
        // 注意：大部分Actor实际上都有一些状态，这里列出的是状态影响最小的
        // 实际使用中可以根据具体业务需求调整
    }};

    /**
     * 获取Actor的持久化优先级
     * @param actorClassName Actor类名
     * @return 优先级：1-关键，2-业务，3-临时，4-无状态
     */
    public static int getActorPersistencePriority(String actorClassName) {
        // 提取简单类名
        String simpleClassName = actorClassName.substring(actorClassName.lastIndexOf('.') + 1);
        
        if (CRITICAL_STATE_ACTORS.containsKey(simpleClassName)) {
            return 1; // 关键状态
        } else if (BUSINESS_STATE_ACTORS.containsKey(simpleClassName)) {
            return 2; // 业务状态
        } else if (TEMPORARY_STATE_ACTORS.containsKey(simpleClassName)) {
            return 3; // 临时状态
        } else {
            return 4; // 无状态或未分类
        }
    }

    /**
     * 获取Actor的状态描述
     * @param actorClassName Actor类名
     * @return 状态描述
     */
    public static String getActorStateDescription(String actorClassName) {
        String simpleClassName = actorClassName.substring(actorClassName.lastIndexOf('.') + 1);
        
        String description = CRITICAL_STATE_ACTORS.get(simpleClassName);
        if (description != null) return description;
        
        description = BUSINESS_STATE_ACTORS.get(simpleClassName);
        if (description != null) return description;
        
        description = TEMPORARY_STATE_ACTORS.get(simpleClassName);
        if (description != null) return description;
        
        return "未分类Actor，需要进一步分析状态特征";
    }

    /**
     * 获取推荐的持久化策略
     * @param actorClassName Actor类名
     * @return 持久化策略建议
     */
    public static String getRecommendedPersistenceStrategy(String actorClassName) {
        int priority = getActorPersistencePriority(actorClassName);
        
        switch (priority) {
            case 1:
                return "强制启用持久化，快照间隔100事件，保留5个快照";
            case 2:
                return "建议启用持久化，快照间隔500事件，保留3个快照";
            case 3:
                return "可选启用持久化，快照间隔1000事件，保留2个快照";
            case 4:
            default:
                return "不建议启用持久化，或仅在特殊场景下启用";
        }
    }

    /**
     * 获取所有已分类的Actor统计信息
     * @return 分类统计
     */
    public static Map<String, Integer> getActorClassificationStats() {
        Map<String, Integer> stats = new HashMap<>();
        stats.put("关键状态Actor", CRITICAL_STATE_ACTORS.size());
        stats.put("业务状态Actor", BUSINESS_STATE_ACTORS.size());
        stats.put("临时状态Actor", TEMPORARY_STATE_ACTORS.size());
        stats.put("无状态Actor", STATELESS_ACTORS.size());
        return stats;
    }

    /**
     * 打印Actor分类报告
     */
    public static void printClassificationReport() {
        System.out.println("=== DataLink节点Actor状态分析报告 ===\n");
        
        System.out.println("1. 关键状态Actor（必须持久化）：");
        CRITICAL_STATE_ACTORS.forEach((actor, desc) -> 
            System.out.println("   - " + actor + ": " + desc));
        
        System.out.println("\n2. 业务状态Actor（建议持久化）：");
        BUSINESS_STATE_ACTORS.forEach((actor, desc) -> 
            System.out.println("   - " + actor + ": " + desc));
        
        System.out.println("\n3. 临时状态Actor（可选持久化）：");
        TEMPORARY_STATE_ACTORS.forEach((actor, desc) -> 
            System.out.println("   - " + actor + ": " + desc));
        
        System.out.println("\n4. 统计信息：");
        getActorClassificationStats().forEach((category, count) -> 
            System.out.println("   - " + category + ": " + count + "个"));
        
        System.out.println("\n=== 报告结束 ===");
    }

    /**
     * 主方法，用于测试和生成报告
     */
    public static void main(String[] args) {
        printClassificationReport();
        
        // 测试几个Actor的分类
        String[] testActors = {
            "com.leon.datalink.rule.actor.RuleActor",
            "com.leon.datalink.node.actor.ScheduleNodeActor",
            "com.leon.datalink.node.actor.DriverNodeActor",
            "com.leon.datalink.node.actor.DelayNodeActor"
        };
        
        System.out.println("\n=== Actor分类测试 ===");
        for (String actor : testActors) {
            int priority = getActorPersistencePriority(actor);
            String description = getActorStateDescription(actor);
            String strategy = getRecommendedPersistenceStrategy(actor);
            
            System.out.println("\nActor: " + actor);
            System.out.println("优先级: " + priority);
            System.out.println("描述: " + description);
            System.out.println("策略: " + strategy);
        }
    }
}
